package Listtest;

import java.util.Arrays;

public class MyArraylist {

        public int[] elem;
        public int usedSize;//0
        //默认容量
        private static final int DEFAULT_SIZE = 10;

        public MyArraylist() {
                this.elem = new int[DEFAULT_SIZE];
        }
        /**
         * 打印顺序表:
         * 根据usedSize判断即可
         */
        public void display() {
                for (int i = 0; i <usedSize; i++) {
                        System.out.print(elem[i]+" ");
                }
        }

        // 新增元素,默认在数组最后新增
        public void add(int data) {
                if(isFull()){
                 grow();
                }
                elem[usedSize]=data;
                usedSize++;
        }
        private void grow(){
                this.elem= Arrays.copyOf(this.elem,2*this.elem.length);
        }

        /**
         * 判断当前的顺序表是不是满的！
         *
         * @return true:满   false代表空
         */
        public boolean isFull() {
                return usedSize==elem.length;
        }
        private void checkPosInAdd(int pos)throws PosIllegal {
                if(pos<0||pos>usedSize){
                        throw new PosIllegal("Pos位置不合法");
                }
        }

        // 在 pos 位置新增元素
        public void add(int pos, int data) {
                try{
                        checkPosInAdd(pos);
                        if(isFull()){
                                grow();
                        }
                        for (int i = usedSize-1; i >=pos; i++) {
                                elem[usedSize]=elem[usedSize-1];
                        }
                        elem[pos]=data;
                }catch (PosIllegal e){
                        System.out.println("插入的位置不合法");
                        e.printStackTrace();
                }
        }

        // 判定是否包含某个元素
        public boolean contains(int toFind) {
                for (int i = 0; i <usedSize; i++) {
                        if(elem[i]==toFind){
                                return true;
                        }
                }
                return false;
        }

        // 查找某个元素对应的位置
        public int indexOf(int toFind) {
                for (int i = 0; i <usedSize; i++) {
                        if(elem[i]==toFind){
                                return i;
                        }
                }
                return -1;
        }
        private void checkEmpty(){
                if(isEmpty()){
                        throw new EmptyExpection("顺序表为空");
                }
        }
        public boolean isEmpty(){
                return usedSize==0;
        }
        private void checkPos(int pos)throws PosIllegal {
                if(pos<0||pos>=usedSize){
                        throw new PosIllegal("Pos位置不合法");
                }
        }

        // 获取 pos 位置的元素
        public int get(int pos) {
                try{
                        checkEmpty();
                        checkPos(pos);
                        return elem[pos];
                }catch (PosIllegal e){
                        e.printStackTrace();
                }catch (Exception e){
                        e.printStackTrace();
                }
                return -1;
        }


        // 给 pos 位置的元素设为【更新为】 value
        public void set(int pos, int value) {
                try{
                        checkEmpty();
                        checkPos(pos);
                        elem[pos]=value;
                }catch (PosIllegal e){
                        e.printStackTrace();
                }catch (EmptyExpection e){
                        e.printStackTrace();
                }

        }

        /**
         * 删除第一次出现的关键字key
         *
         * @param key
         */
        public void remove(int key) {
                try {
                        checkEmpty();
                        int pos=indexOf(key);
                        if(pos==-1){
                                return;
                        }
                        for (int i=pos; i <usedSize-1 ; i++) {
                                elem[pos]=elem[pos+1];
                        }
                        usedSize--;
                }catch (EmptyExpection e){
                        e.printStackTrace();
                }

        }

        // 获取顺序表长度
        public int size() {
                return usedSize;
        }

        // 清空顺序表
        public void clear() {
                usedSize=0;
        }
}